//
// CVertexBuffer.java
// Copyright (C) 2010  "Naush" <naush _ hotmail _ fr>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>./* ----------------------------------------------------------------------------







package org.ryzom.nel.threed;

import org.ryzom.nel.misc.CRefCount;
import org.ryzom.nel.misc.IStream;

public class CVertexBuffer extends CRefCount {
  private long swigCPtr;

  public CVertexBuffer(long cPtr, boolean cMemoryOwn) {
    super(nel3dJNI.CVertexBuffer_SWIGUpcast(cPtr), cMemoryOwn);
    swigCPtr = cPtr;
  }

  public static long getCPtr(CVertexBuffer obj) {
    return (obj == null) ? 0 : obj.swigCPtr;
  }

  protected void finalize() {
    delete();
  }

  public synchronized void delete() {
    if (swigCPtr != 0) {
      if (swigCMemOwn) {
        swigCMemOwn = false;
        nel3dJNI.delete_CVertexBuffer(swigCPtr);
      }
      swigCPtr = 0;
    }
    super.delete();
  }

  public static SWIGTYPE_p_unsigned_int getSizeType() {
    long cPtr = nel3dJNI.CVertexBuffer_SizeType_get();
    return (cPtr == 0) ? null : new SWIGTYPE_p_unsigned_int(cPtr, false);
  }

  public static SWIGTYPE_p_NL3D__CVertexBuffer__TType getDefaultValueType() {
    long cPtr = nel3dJNI.CVertexBuffer_DefaultValueType_get();
    return (cPtr == 0) ? null : new SWIGTYPE_p_NL3D__CVertexBuffer__TType(cPtr, false);
  }

  public static SWIGTYPE_p_unsigned_int getNumComponentsType() {
    long cPtr = nel3dJNI.CVertexBuffer_NumComponentsType_get();
    return (cPtr == 0) ? null : new SWIGTYPE_p_unsigned_int(cPtr, false);
  }

  public void setDrvInfos(SWIGTYPE_p_CRefPtrT_NL3D__IVBDrvInfos_t value) {
    nel3dJNI.CVertexBuffer_DrvInfos_set(swigCPtr, this, SWIGTYPE_p_CRefPtrT_NL3D__IVBDrvInfos_t.getCPtr(value));
  }

  public SWIGTYPE_p_CRefPtrT_NL3D__IVBDrvInfos_t getDrvInfos() {
    long cPtr = nel3dJNI.CVertexBuffer_DrvInfos_get(swigCPtr, this);
    return (cPtr == 0) ? null : new SWIGTYPE_p_CRefPtrT_NL3D__IVBDrvInfos_t(cPtr, false);
  }

  public long getTouchFlags() {
    return nel3dJNI.CVertexBuffer_getTouchFlags(swigCPtr, this);
  }

  public void setLocation(CVertexBuffer.TLocation newLocation) {
    nel3dJNI.CVertexBuffer_setLocation(swigCPtr, this, newLocation.swigValue());
  }

  public void fillBuffer() {
    nel3dJNI.CVertexBuffer_fillBuffer(swigCPtr, this);
  }

  public CVertexBuffer() {
    this(nel3dJNI.new_CVertexBuffer__SWIG_0(), true);
  }

  public CVertexBuffer(String name) {
    this(nel3dJNI.new_CVertexBuffer__SWIG_1(name), true);
  }

  public CVertexBuffer(CVertexBuffer vb) {
    this(nel3dJNI.new_CVertexBuffer__SWIG_2(CVertexBuffer.getCPtr(vb), vb), true);
  }

  public CVertexBuffer assign(CVertexBuffer vb) {
    return new CVertexBuffer(nel3dJNI.CVertexBuffer_assign(swigCPtr, this, CVertexBuffer.getCPtr(vb), vb), false);
  }

  public void copyVertices(CVertexBuffer dest) {
    nel3dJNI.CVertexBuffer_copyVertices(swigCPtr, this, CVertexBuffer.getCPtr(dest), dest);
  }

  public void setPreferredMemory(CVertexBuffer.TPreferredMemory preferredMemory, boolean keepLocalMemory) {
    nel3dJNI.CVertexBuffer_setPreferredMemory(swigCPtr, this, preferredMemory.swigValue(), keepLocalMemory);
  }

  public CVertexBuffer.TPreferredMemory getPreferredMemory() {
    return CVertexBuffer.TPreferredMemory.swigToEnum(nel3dJNI.CVertexBuffer_getPreferredMemory(swigCPtr, this));
  }

  public boolean getKeepLocalMemory() {
    return nel3dJNI.CVertexBuffer_getKeepLocalMemory(swigCPtr, this);
  }

  public CVertexBuffer.TLocation getLocation() {
    return CVertexBuffer.TLocation.swigToEnum(nel3dJNI.CVertexBuffer_getLocation(swigCPtr, this));
  }

  public boolean isResident() {
    return nel3dJNI.CVertexBuffer_isResident(swigCPtr, this);
  }

  public boolean setVertexFormat(long Flags) {
    return nel3dJNI.CVertexBuffer_setVertexFormat(swigCPtr, this, Flags);
  }

  public long getVertexFormat() {
    return nel3dJNI.CVertexBuffer_getVertexFormat(swigCPtr, this);
  }

  public long getNumTexCoordUsed() {
    return nel3dJNI.CVertexBuffer_getNumTexCoordUsed(swigCPtr, this);
  }

  public int getNormalOff() {
    return nel3dJNI.CVertexBuffer_getNormalOff(swigCPtr, this);
  }

  public int getTexCoordOff(short stage) {
    return nel3dJNI.CVertexBuffer_getTexCoordOff__SWIG_0(swigCPtr, this, stage);
  }

  public int getTexCoordOff() {
    return nel3dJNI.CVertexBuffer_getTexCoordOff__SWIG_1(swigCPtr, this);
  }

  public int getColorOff() {
    return nel3dJNI.CVertexBuffer_getColorOff(swigCPtr, this);
  }

  public int getSpecularOff() {
    return nel3dJNI.CVertexBuffer_getSpecularOff(swigCPtr, this);
  }

  public int getWeightOff(int wgt) {
    return nel3dJNI.CVertexBuffer_getWeightOff(swigCPtr, this, wgt);
  }

  public int getPaletteSkinOff() {
    return nel3dJNI.CVertexBuffer_getPaletteSkinOff(swigCPtr, this);
  }

  public static CVertexBuffer.TValue getValueIdByNumberEx(long valueNumber) {
    return CVertexBuffer.TValue.swigToEnum(nel3dJNI.CVertexBuffer_getValueIdByNumberEx(valueNumber));
  }

  public void clearValueEx() {
    nel3dJNI.CVertexBuffer_clearValueEx(swigCPtr, this);
  }

  public void addValueEx(CVertexBuffer.TValue valueId, CVertexBuffer.TType type) {
    nel3dJNI.CVertexBuffer_addValueEx(swigCPtr, this, valueId.swigValue(), type.swigValue());
  }

  public boolean hasValueEx(CVertexBuffer.TValue valueId) {
    return nel3dJNI.CVertexBuffer_hasValueEx(swigCPtr, this, valueId.swigValue());
  }

  public void initEx() {
    nel3dJNI.CVertexBuffer_initEx(swigCPtr, this);
  }

  public int getValueOffEx(CVertexBuffer.TValue valueId) {
    return nel3dJNI.CVertexBuffer_getValueOffEx(swigCPtr, this, valueId.swigValue());
  }

  public void setNumVertices(long n) {
    nel3dJNI.CVertexBuffer_setNumVertices(swigCPtr, this, n);
  }

  public long getNumVertices() {
    return nel3dJNI.CVertexBuffer_getNumVertices(swigCPtr, this);
  }

  public void deleteAllVertices() {
    nel3dJNI.CVertexBuffer_deleteAllVertices(swigCPtr, this);
  }

  public void reserve(long nVerts) {
    nel3dJNI.CVertexBuffer_reserve(swigCPtr, this, nVerts);
  }

  public long capacity() {
    return nel3dJNI.CVertexBuffer_capacity(swigCPtr, this);
  }

  public long getVertexSize() {
    return nel3dJNI.CVertexBuffer_getVertexSize(swigCPtr, this);
  }

  public CVertexBuffer.TType getValueType(long value) {
    return CVertexBuffer.TType.swigToEnum(nel3dJNI.CVertexBuffer_getValueType(swigCPtr, this, value));
  }

  public SWIGTYPE_p_unsigned_char getValueTypePointer() {
    long cPtr = nel3dJNI.CVertexBuffer_getValueTypePointer(swigCPtr, this);
    return (cPtr == 0) ? null : new SWIGTYPE_p_unsigned_char(cPtr, false);
  }

  public short getNumWeight() {
    return nel3dJNI.CVertexBuffer_getNumWeight(swigCPtr, this);
  }

  public void serial(IStream f) {
    nel3dJNI.CVertexBuffer_serial(swigCPtr, this, IStream.getCPtr(f), f);
  }

  public void lock(CVertexBufferReadWrite accessor, long first, long last) {
    nel3dJNI.CVertexBuffer_lock__SWIG_0(swigCPtr, this, CVertexBufferReadWrite.getCPtr(accessor), accessor, first, last);
  }

  public void lock(CVertexBufferReadWrite accessor, long first) {
    nel3dJNI.CVertexBuffer_lock__SWIG_1(swigCPtr, this, CVertexBufferReadWrite.getCPtr(accessor), accessor, first);
  }

  public void lock(CVertexBufferReadWrite accessor) {
    nel3dJNI.CVertexBuffer_lock__SWIG_2(swigCPtr, this, CVertexBufferReadWrite.getCPtr(accessor), accessor);
  }

  public void lock(CVertexBufferRead accessor, long first, long last) {
    nel3dJNI.CVertexBuffer_lock__SWIG_3(swigCPtr, this, CVertexBufferRead.getCPtr(accessor), accessor, first, last);
  }

  public void lock(CVertexBufferRead accessor, long first) {
    nel3dJNI.CVertexBuffer_lock__SWIG_4(swigCPtr, this, CVertexBufferRead.getCPtr(accessor), accessor, first);
  }

  public void lock(CVertexBufferRead accessor) {
    nel3dJNI.CVertexBuffer_lock__SWIG_5(swigCPtr, this, CVertexBufferRead.getCPtr(accessor), accessor);
  }

  public boolean isLocked() {
    return nel3dJNI.CVertexBuffer_isLocked(swigCPtr, this);
  }

  public void serialHeader(IStream f) {
    nel3dJNI.CVertexBuffer_serialHeader(swigCPtr, this, IStream.getCPtr(f), f);
  }

  public void serialSubset(IStream f, long vertexStart, long vertexEnd) {
    nel3dJNI.CVertexBuffer_serialSubset(swigCPtr, this, IStream.getCPtr(f), f, vertexStart, vertexEnd);
  }

  public SWIGTYPE_p_unsigned_char getUVRouting() {
    long cPtr = nel3dJNI.CVertexBuffer_getUVRouting(swigCPtr, this);
    return (cPtr == 0) ? null : new SWIGTYPE_p_unsigned_char(cPtr, false);
  }

  public void setUVRouting(short uvChannel, long newUVRouting) {
    nel3dJNI.CVertexBuffer_setUVRouting(swigCPtr, this, uvChannel, newUVRouting);
  }

  public boolean setVertexColorFormat(CVertexBuffer.TVertexColorType format) {
    return nel3dJNI.CVertexBuffer_setVertexColorFormat(swigCPtr, this, format.swigValue());
  }

  public CVertexBuffer.TVertexColorType getVertexColorFormat() {
    return CVertexBuffer.TVertexColorType.swigToEnum(nel3dJNI.CVertexBuffer_getVertexColorFormat(swigCPtr, this));
  }

  public void dumpFormat() {
    nel3dJNI.CVertexBuffer_dumpFormat(swigCPtr, this);
  }

  public void setName(String name) {
    nel3dJNI.CVertexBuffer_setName(swigCPtr, this, name);
  }

  public String getName() {
    return nel3dJNI.CVertexBuffer_getName(swigCPtr, this);
  }

  public final static class TPreferredMemory {
    public final static TPreferredMemory RAMPreferred = new TPreferredMemory("RAMPreferred", nel3dJNI.CVertexBuffer_RAMPreferred_get());
    public final static TPreferredMemory AGPPreferred = new TPreferredMemory("AGPPreferred");
    public final static TPreferredMemory StaticPreferred = new TPreferredMemory("StaticPreferred");
    public final static TPreferredMemory RAMVolatile = new TPreferredMemory("RAMVolatile");
    public final static TPreferredMemory AGPVolatile = new TPreferredMemory("AGPVolatile");
    public final static TPreferredMemory PreferredCount = new TPreferredMemory("PreferredCount");

    public final int swigValue() {
      return swigValue;
    }

    public String toString() {
      return swigName;
    }

    public static TPreferredMemory swigToEnum(int swigValue) {
      if (swigValue < swigValues.length && swigValue >= 0 && swigValues[swigValue].swigValue == swigValue)
        return swigValues[swigValue];
      for (int i = 0; i < swigValues.length; i++)
        if (swigValues[i].swigValue == swigValue)
          return swigValues[i];
      throw new IllegalArgumentException("No enum " + TPreferredMemory.class + " with value " + swigValue);
    }

    private TPreferredMemory(String swigName) {
      this.swigName = swigName;
      this.swigValue = swigNext++;
    }

    private TPreferredMemory(String swigName, int swigValue) {
      this.swigName = swigName;
      this.swigValue = swigValue;
      swigNext = swigValue+1;
    }

    private TPreferredMemory(String swigName, TPreferredMemory swigEnum) {
      this.swigName = swigName;
      this.swigValue = swigEnum.swigValue;
      swigNext = this.swigValue+1;
    }

    private static TPreferredMemory[] swigValues = { RAMPreferred, AGPPreferred, StaticPreferred, RAMVolatile, AGPVolatile, PreferredCount };
    private static int swigNext = 0;
    private final int swigValue;
    private final String swigName;
  }

  public final static class TLocation {
    public final static TLocation RAMResident = new TLocation("RAMResident", nel3dJNI.CVertexBuffer_RAMResident_get());
    public final static TLocation AGPResident = new TLocation("AGPResident");
    public final static TLocation VRAMResident = new TLocation("VRAMResident");
    public final static TLocation NotResident = new TLocation("NotResident");
    public final static TLocation LocationCount = new TLocation("LocationCount");

    public final int swigValue() {
      return swigValue;
    }

    public String toString() {
      return swigName;
    }

    public static TLocation swigToEnum(int swigValue) {
      if (swigValue < swigValues.length && swigValue >= 0 && swigValues[swigValue].swigValue == swigValue)
        return swigValues[swigValue];
      for (int i = 0; i < swigValues.length; i++)
        if (swigValues[i].swigValue == swigValue)
          return swigValues[i];
      throw new IllegalArgumentException("No enum " + TLocation.class + " with value " + swigValue);
    }

    private TLocation(String swigName) {
      this.swigName = swigName;
      this.swigValue = swigNext++;
    }

    private TLocation(String swigName, int swigValue) {
      this.swigName = swigName;
      this.swigValue = swigValue;
      swigNext = swigValue+1;
    }

    private TLocation(String swigName, TLocation swigEnum) {
      this.swigName = swigName;
      this.swigValue = swigEnum.swigValue;
      swigNext = this.swigValue+1;
    }

    private static TLocation[] swigValues = { RAMResident, AGPResident, VRAMResident, NotResident, LocationCount };
    private static int swigNext = 0;
    private final int swigValue;
    private final String swigName;
  }

  public final static class TValue {
    public final static TValue Position = new TValue("Position", nel3dJNI.CVertexBuffer_Position_get());
    public final static TValue Normal = new TValue("Normal", nel3dJNI.CVertexBuffer_Normal_get());
    public final static TValue TexCoord0 = new TValue("TexCoord0", nel3dJNI.CVertexBuffer_TexCoord0_get());
    public final static TValue TexCoord1 = new TValue("TexCoord1", nel3dJNI.CVertexBuffer_TexCoord1_get());
    public final static TValue TexCoord2 = new TValue("TexCoord2", nel3dJNI.CVertexBuffer_TexCoord2_get());
    public final static TValue TexCoord3 = new TValue("TexCoord3", nel3dJNI.CVertexBuffer_TexCoord3_get());
    public final static TValue TexCoord4 = new TValue("TexCoord4", nel3dJNI.CVertexBuffer_TexCoord4_get());
    public final static TValue TexCoord5 = new TValue("TexCoord5", nel3dJNI.CVertexBuffer_TexCoord5_get());
    public final static TValue TexCoord6 = new TValue("TexCoord6", nel3dJNI.CVertexBuffer_TexCoord6_get());
    public final static TValue TexCoord7 = new TValue("TexCoord7", nel3dJNI.CVertexBuffer_TexCoord7_get());
    public final static TValue PrimaryColor = new TValue("PrimaryColor", nel3dJNI.CVertexBuffer_PrimaryColor_get());
    public final static TValue SecondaryColor = new TValue("SecondaryColor", nel3dJNI.CVertexBuffer_SecondaryColor_get());
    public final static TValue Weight = new TValue("Weight", nel3dJNI.CVertexBuffer_Weight_get());
    public final static TValue PaletteSkin = new TValue("PaletteSkin", nel3dJNI.CVertexBuffer_PaletteSkin_get());
    public final static TValue Fog = new TValue("Fog", nel3dJNI.CVertexBuffer_Fog_get());
    public final static TValue Empty = new TValue("Empty", nel3dJNI.CVertexBuffer_Empty_get());
    public final static TValue NumValue = new TValue("NumValue", nel3dJNI.CVertexBuffer_NumValue_get());

    public final int swigValue() {
      return swigValue;
    }

    public String toString() {
      return swigName;
    }

    public static TValue swigToEnum(int swigValue) {
      if (swigValue < swigValues.length && swigValue >= 0 && swigValues[swigValue].swigValue == swigValue)
        return swigValues[swigValue];
      for (int i = 0; i < swigValues.length; i++)
        if (swigValues[i].swigValue == swigValue)
          return swigValues[i];
      throw new IllegalArgumentException("No enum " + TValue.class + " with value " + swigValue);
    }

    private TValue(String swigName) {
      this.swigName = swigName;
      this.swigValue = swigNext++;
    }

    private TValue(String swigName, int swigValue) {
      this.swigName = swigName;
      this.swigValue = swigValue;
      swigNext = swigValue+1;
    }

    private TValue(String swigName, TValue swigEnum) {
      this.swigName = swigName;
      this.swigValue = swigEnum.swigValue;
      swigNext = this.swigValue+1;
    }

    private static TValue[] swigValues = { Position, Normal, TexCoord0, TexCoord1, TexCoord2, TexCoord3, TexCoord4, TexCoord5, TexCoord6, TexCoord7, PrimaryColor, SecondaryColor, Weight, PaletteSkin, Fog, Empty, NumValue };
    private static int swigNext = 0;
    private final int swigValue;
    private final String swigName;
  }

  public final static int FirstTexCoordValue = nel3dJNI.CVertexBuffer_FirstTexCoordValue_get();
  public final static int LastTexCoordValue = nel3dJNI.CVertexBuffer_LastTexCoordValue_get();

  public final static int PositionFlag = nel3dJNI.CVertexBuffer_PositionFlag_get();
  public final static int NormalFlag = nel3dJNI.CVertexBuffer_NormalFlag_get();
  public final static int TexCoord0Flag = nel3dJNI.CVertexBuffer_TexCoord0Flag_get();
  public final static int TexCoord1Flag = nel3dJNI.CVertexBuffer_TexCoord1Flag_get();
  public final static int TexCoord2Flag = nel3dJNI.CVertexBuffer_TexCoord2Flag_get();
  public final static int TexCoord3Flag = nel3dJNI.CVertexBuffer_TexCoord3Flag_get();
  public final static int TexCoord4Flag = nel3dJNI.CVertexBuffer_TexCoord4Flag_get();
  public final static int TexCoord5Flag = nel3dJNI.CVertexBuffer_TexCoord5Flag_get();
  public final static int TexCoord6Flag = nel3dJNI.CVertexBuffer_TexCoord6Flag_get();
  public final static int TexCoord7Flag = nel3dJNI.CVertexBuffer_TexCoord7Flag_get();
  public final static int PrimaryColorFlag = nel3dJNI.CVertexBuffer_PrimaryColorFlag_get();
  public final static int SecondaryColorFlag = nel3dJNI.CVertexBuffer_SecondaryColorFlag_get();
  public final static int WeightFlag = nel3dJNI.CVertexBuffer_WeightFlag_get();
  public final static int PaletteSkinFlag = nel3dJNI.CVertexBuffer_PaletteSkinFlag_get();
  public final static int FogFlag = nel3dJNI.CVertexBuffer_FogFlag_get();
  public final static int EmptyFlag = nel3dJNI.CVertexBuffer_EmptyFlag_get();

  public final static class TType {
    public final static TType Double1 = new TType("Double1", nel3dJNI.CVertexBuffer_Double1_get());
    public final static TType Float1 = new TType("Float1");
    public final static TType Short1 = new TType("Short1");
    public final static TType Double2 = new TType("Double2");
    public final static TType Float2 = new TType("Float2");
    public final static TType Short2 = new TType("Short2");
    public final static TType Double3 = new TType("Double3");
    public final static TType Float3 = new TType("Float3");
    public final static TType Short3 = new TType("Short3");
    public final static TType Double4 = new TType("Double4");
    public final static TType Float4 = new TType("Float4");
    public final static TType Short4 = new TType("Short4");
    public final static TType UChar4 = new TType("UChar4");
    public final static TType NumType = new TType("NumType");

    public final int swigValue() {
      return swigValue;
    }

    public String toString() {
      return swigName;
    }

    public static TType swigToEnum(int swigValue) {
      if (swigValue < swigValues.length && swigValue >= 0 && swigValues[swigValue].swigValue == swigValue)
        return swigValues[swigValue];
      for (int i = 0; i < swigValues.length; i++)
        if (swigValues[i].swigValue == swigValue)
          return swigValues[i];
      throw new IllegalArgumentException("No enum " + TType.class + " with value " + swigValue);
    }

    private TType(String swigName) {
      this.swigName = swigName;
      this.swigValue = swigNext++;
    }

    private TType(String swigName, int swigValue) {
      this.swigName = swigName;
      this.swigValue = swigValue;
      swigNext = swigValue+1;
    }

    private TType(String swigName, TType swigEnum) {
      this.swigName = swigName;
      this.swigValue = swigEnum.swigValue;
      swigNext = this.swigValue+1;
    }

    private static TType[] swigValues = { Double1, Float1, Short1, Double2, Float2, Short2, Double3, Float3, Short3, Double4, Float4, Short4, UChar4, NumType };
    private static int swigNext = 0;
    private final int swigValue;
    private final String swigName;
  }

  public final static int MaxStage = nel3dJNI.CVertexBuffer_MaxStage_get();
  public final static int MaxWeight = nel3dJNI.CVertexBuffer_MaxWeight_get();

  public final static class TVertexColorType {
    public final static TVertexColorType TRGBA = new TVertexColorType("TRGBA", nel3dJNI.CVertexBuffer_TRGBA_get());
    public final static TVertexColorType TBGRA = new TVertexColorType("TBGRA", nel3dJNI.CVertexBuffer_TBGRA_get());

    public final int swigValue() {
      return swigValue;
    }

    public String toString() {
      return swigName;
    }

    public static TVertexColorType swigToEnum(int swigValue) {
      if (swigValue < swigValues.length && swigValue >= 0 && swigValues[swigValue].swigValue == swigValue)
        return swigValues[swigValue];
      for (int i = 0; i < swigValues.length; i++)
        if (swigValues[i].swigValue == swigValue)
          return swigValues[i];
      throw new IllegalArgumentException("No enum " + TVertexColorType.class + " with value " + swigValue);
    }

    private TVertexColorType(String swigName) {
      this.swigName = swigName;
      this.swigValue = swigNext++;
    }

    private TVertexColorType(String swigName, int swigValue) {
      this.swigName = swigName;
      this.swigValue = swigValue;
      swigNext = swigValue+1;
    }

    private TVertexColorType(String swigName, TVertexColorType swigEnum) {
      this.swigName = swigName;
      this.swigValue = swigEnum.swigValue;
      swigNext = this.swigValue+1;
    }

    private static TVertexColorType[] swigValues = { TRGBA, TBGRA };
    private static int swigNext = 0;
    private final int swigValue;
    private final String swigName;
  }

  public final static int TouchedVertexFormat = nel3dJNI.CVertexBuffer_TouchedVertexFormat_get();
  public final static int TouchedNumVertices = nel3dJNI.CVertexBuffer_TouchedNumVertices_get();
  public final static int TouchedReserve = nel3dJNI.CVertexBuffer_TouchedReserve_get();
  public final static int TouchedAll = nel3dJNI.CVertexBuffer_TouchedAll_get();

}
